Instead of going infinitely deep, we could instead search up to level two and collect entries that are non-text. This way we don't have to bother with escaping keys etc. Here is an idea; I haven't tested it so there might be a few errors:

class ArbHandler(JsonHandler):
    ...

    def parse(self, content, **kwargs):
        ...

        keys = self._find_keys(parsed)
        stringset = self._extract(parsed, keys)

    def _find_keys(self, parsed):
        if parsed.type != dict:
            raise ParseError("...")

        keys, keys_to_ignore = set(), set()
        for key, key_position, value, _ in parsed:
            if not key.startswith("@"):
                if not isinstance(value, str):
                    continue
                if key in keys:
                    raise ParseError(
                        f"Duplicate string key ('{key}') in line "
                        f"{self.transcriber.line_number}"
                    )
                keys.add(key)
            else:
                if isinstance(value, DumbJson):
                    (inner_value, _), = value.find_children('type')
                    if inner_value != "text":
                        keys_to_ignore.add(key)
        return keys - keys_to_ignore

    def _extract(self, parsed, keys):
        stringset = []
        for key, _, value, value_position in parsed:
            if key not in keys:
                continue
            ...
        return stringset

Did not try this. Anyway, ARBs normally have only two levels of json, so we don't expect infinite nesting.

So, the only reason you re-define compile and _copy_until_and_remove_section is so that you can add the keep_sections functionality, which is only needed for testing. I am not very fond of this idea. It makes the code unnecessarily complex. However, there is a case where not removing the sections makes sense.

This is not adequately described in the docs, but when Transifex invokes this handler, it will pass is_source as a keyword argument. In this case, we can be certain that

1. the stringset will not be missing anything and that
2. the user wants to get the exact same file they previously uploaded

So, if this is indeed the same use-case, maybe you can rename keep_sections to is_source.

In any case, lets make sure that when is_source=True is passed to compile, the end result is the same as the originally uploaded file.

Tried this, replaced keep_sections with is_source, but that did not work, unit-tests failed. Anyway, re-definition of the compile() method is necessary now, as it handles language code for ARB.

No need for this check, we already did it in _find_keys. Perhaps to make it clearer, lets make one check in parse and then in _find_keys and _extract assume that parsed represents a dict.

done

Implemented issue 1 from QA spreadsheet

Implemented issue 2 from QA spreadsheet

Implemented issue 3 from QA spreadsheet